import { Controller } from 'egg';
import {Op} from 'sequelize'
export default class AdminController extends Controller {
    //登录
    /**
     * @api {post} /manage/login 管理员登录
     * @apiName manageLogin
     * @apiGroup Admin
     * @apiVersion 1.0.0
     * @apiDescription 管理员登录
     * @apiParam {String} user_name  用户名
     * @apiParam {String} password  密码
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 数据主体结构
     * @apiSuccess {Number} data.admin_id 用户ID
     * @apiSuccess {String} data.user_name 用户名
     * @apiSuccess {String} data.token jwt认证token
     * @apiSuccess {String} data.real_name 用户密码
     * @apiSuccess {String} data.about_name 公司名称
     *
     */
    /**
     * 过程：
     *  将传过来的用户密码加密后，根据账号密码查询管理员信息，
     *   
     */
    async login(){
        const {ctx}=this;
        const {body}=ctx.request;
        if(!body.user_name||!body.password){
            return ctx.body=ctx.helper.error_result("需要用户名和密码");
        }
        body.password=ctx.helper.md5(body.password);
        let condition={
            user_name:body.user_name,
            password:body.password
        }
        let result=await ctx.service.admin.find_one(condition);
        ctx.body=result;
    }
    //登录
    /**
     * @api {get} /manage/admin_info 管理员详情
     * @apiName adminInfo
     * @apiGroup Admin
     * @apiVersion 1.0.0
     * @apiDescription 管理员详情
     * @apiParam {Number} admin_id  管理员ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 数据主体结构
     * @apiSuccess {Number} data.admin_id 用户ID
     * @apiSuccess {String} data.user_name 用户名
     * @apiSuccess {String} data.real_name 用户真实名称
     * @apiSuccess {String} data.about_id 公司ID
     * @apiSuccess {String} data.about_name 公司名称
     *
     */
    /**
     * 过程：
     *  管理员详情查询
     *   
     */
    async info(){
        const {ctx}=this;
        const {query}=ctx.request;
        if(!query.admin_id){
            return ctx.body=ctx.helper.error_result("未指定需要查询的管理员ID");
        }
        let condition={
            admin_id:query.admin_id
        }
        return ctx.body=await ctx.service.admin.find_one(condition);
    }
    //新增管理员
    /**
     * @api {post} /manage/admin_add 管理员新增
     * @apiName manageAdd
     * @apiGroup Admin
     * @apiVersion 1.0.0
     * @apiDescription 管理员新增
     * @apiParam {String} user_name  用户名
     * @apiParam {String} password  密码
     * @apiParam {String} confirm_pass  确认密码
     * @apiParam {String} real_name  真实姓名
     * @apiParam {String} phone  电话
     * @apiParam {String} email  邮箱
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     */
    /**
     * 过程：
     * 管理员新增逻辑处理
     */
    async add(){
        const {ctx}=this;
        const {body}=ctx.request;
        if(!body.user_name||!body.password||!body.confirm_pass){
            return ctx.body=ctx.helper.error_result("用户名或密码输入失败");
        }
        if(body.password!=body.confirm_pass){
            return ctx.body=ctx.helper.error_result("两次密码不一致，请确认后再次提交");
        }
        body.password=ctx.helper.md5(body.password);   
        try {
            await this.app.model.Admin.create(body);
            ctx.body=ctx.helper.success_result("操作成功");   
        } catch (error) {
            ctx.body=ctx.helper.error_result("添加管理员失败");
        }
    }
    //修改管理员
    /**
     * @api {post} /manage/admin_update 管理员修改
     * @apiName adminUpdate
     * @apiGroup Admin
     * @apiVersion 1.0.0
     * @apiDescription 管理员新增
     * @apiParam {Number} admin_id  管理员ID
     * @apiParam {String} user_name  用户名
     * @apiParam {String} password  密码
     * @apiParam {String} confirm_pass  确认密码
     * @apiParam {String} new_pass  新密码
     * @apiParam {String} real_name  真实姓名
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     *
     */

     /**
     * 过程：
     * 管理员修改逻辑处理，
     * 如果是否是修改密码操作，如果是则判断确认密码和新密码是否一致，不一致直接提示错误信息
     * 不是修改密码则过滤非空属性后，直接更新管理员
     */
    async update(){
        const {ctx,app}=this;
        const {body}=ctx.request;
        if(!body.admin_id){
            return ctx.body=ctx.helper.error_result("需要指定要修改的管理员ID");
        }
        if(body.new_pass){
            if(!body.confirm_pass||(body.confirm_pass!=body.new_pass)){
                return ctx.body=ctx.helper.error_result("确认密码和新密码不一致");
            }
            body.password=ctx.helper.md5(body.new_pass);
        }
        let param=ctx.helper.not_null_filter(body);
        let condition={
            admin_id:body.admin_id
        }
        try {
            let result=await app.model.Admin.update(param,{where:condition});
            console.log(result)
            ctx.body=result&&result[0] ? ctx.helper.success_result("操作成功") : ctx.helper.success_result("未修改数据");
        } catch (error) {
            ctx.body=ctx.helper.success_result("修改失败");
        }
        
    }
    //检查管理员密码
    /**
     * @api {post} /manage/pass_check 检查管理员密码
     * @apiName adminPassCheck
     * @apiGroup Admin
     * @apiVersion 1.0.0
     * @apiDescription 检查管理员密码
     * @apiParam {Number} admin_id  管理员ID
     * @apiParam {String} password  密码
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     *
     */
    /**
     * 过程：
     *   验证管理员ID，根据ID查询管理员，没有查询出则提示未找到管理员异常，如果找到
     * 则验证密码是否一致，返回对应结果
     */
    async check(){
        const {ctx,app}=this;
        const {body}=ctx.request;
        if(!body.admin_id){
            return ctx.body=ctx.helper.error_result("需要指定要修改的管理员ID");
        }
        try {
            if(!body.password){
                return ctx.body=ctx.helper.error_result("需要指定对应的管理员密码");
            }
            body.password=ctx.helper.md5(body.password);
            const {Admin}=app.model;
            let admin=await Admin.findByPk(body.admin_id);
            if(!admin){
                return ctx.body=ctx.helper.error_result("未找到对应的管理员");
            }
            if(body.password!=admin['password']){
                return ctx.body=ctx.helper.error_result("密码不匹配");
            }
            return ctx.body=ctx.helper.success_result("成功");
        } catch (error) {
        }
        return ctx.body=ctx.helper.error_result("查询出现异常");
    }
    //删除管理员
    /**
     * @api {post} /manage/admin_del 管理员删除
     * @apiName adminDel
     * @apiGroup Admin
     * @apiVersion 1.0.0
     * @apiDescription 管理员删除
     * @apiParam {Number} admin_id  管理员ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     *
     */
    /**
     * 删除管理员逻辑
     */
    async del(){
        const {ctx,app}=this;
        const {body}=ctx.request;
        if(!body.admin_id){
            return ctx.body=ctx.helper.error_result("没有指定管理员ID");
        }
        try {
            let result=await app.model.Admin.destroy({
                where:{
                    admin_id:body.admin_id
                }
            })
            ctx.body=result ? ctx.helper.success_result("删除成功",result) :ctx.helper.error_result("删除失败!") ;   
        } catch (error) {
            return ctx.body=ctx.helper.error_result("删除管理员失败!");
        }
    }
    /**
     * @api {post} /manage/loginout 管理员退出
     * @apiName adminLoginout
     * @apiGroup Admin
     * @apiVersion 1.0.0
     * @apiDescription 管理员退出
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     */
    /**
     * 登出逻辑：请求中带了token则验证token是否存在，如果存在则解密token,
     * 删除redis中token 返回删除成功
     */
    async loginout(){
        const {ctx,app}=this;
        let token=ctx.header?ctx.header['authorization'] :'';
        if(token){
            let vertify=await ctx.service.token.decode_jwt(token);
            await app.redis.hdel("token",vertify['admin_id']);
            return ctx.body=ctx.helper.success_result("成功退出")
        }
        ctx.body=ctx.helper.error_result("未能成功退出")
    }
    //管理员列表
    /**
     * @api {get} /manage/admin_list 管理员列表
     * @apiName adminList
     * @apiGroup Admin
     * @apiVersion 1.0.0
     * @apiDescription 管理员列表
     * @apiParam {String} keyword  关键字查询
     * @apiParam {Number} page  页面位置
     * @apiParam {Number} page_size  页面尺寸
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 查询结果数据结构
     * @apiSuccess {Object[]} data.data_info 管理员列表
     * @apiSuccess {Number} data.data_info.admin_id 管理员ID
     * @apiSuccess {String} data.data_info.user_name 管理员用户名
     * @apiSuccess {String} data.data_info.real_name 管理员真实名称
     * @apiSuccess {String} data.page_count 页码总数
     * @apiSuccess {String} data.data_count 数据总数
     *
     */
    /**
     * 分页查询所有管理员
     * 参数：
     *  condition 检索条件
     * 输出：
     *   {Number} code 返回状态码 0失败  200成功
     *   {String} message 返回状态对应提示消息
     *   {Object} data 查询结果数据结构
     *   {Object[]} data.data_info 管理员列表
     *   {Number} data.data_info.admin_id 管理员ID
     *   {String} data.data_info.user_name 管理员用户名
     *   {String} data.data_info.real_name 管理员真实名称
     *   {String} data.page_count 页码总数
     *   {String} data.data_count 数据总数
     * 过程：
     *  构建分页查询条件
     *  分页查询数据，分页结果处理逻辑，返回结果
     */
    async list(){
        let {ctx}=this;
        const {query}=ctx.request;
        try {
            let condition:any={}
            if(query.keyword){
                let keyword=query.keyword;
                let like_obj={[Op.like]: '%'+ keyword +'%'};
                condition={
                    ...condition,
                    [Op.or]:[
                        {
                            user_name: like_obj
                        },
                        {
                            real_name:like_obj
                        },{
                            phone:like_obj
                        }
                    ]
                }
            }
            let order_condition=[
                ['create_time', 'DESC']
            ];
            
            let admin_list=await ctx.service.common.find_and_count_all(condition,order_condition,query,'Admin');
            
            ctx.body=admin_list;

        } catch (error) {
            ctx.body=ctx.helper.error_result("查询异常");
        }
    }
}

